/* Copyright (C) 1991 Free Software Foundation, Inc.
This file is part of the GNU C Library.

The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.

The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB.  If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA.  */

#include <ansidecl.h>
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <grp.h>

ssize_t
DEFUN(__getline, (lineptr, n, stream),
      char **lineptr AND size_t *n AND FILE *stream);

static FILE *stream = NULL;


/* This is the function that all the others are based on.
   The format of the group file is known only here.  */

/* Structure containing info kept by each __grpread caller.  */
typedef struct
  {
    char *buf;
    size_t buflen;
    size_t max_members;
    char **members;
    struct group g;
  } grpread_info;


/* Return a chunk of memory containing a pre-initialized `grpread_info'.  */
PTR
DEFUN_VOID(__grpalloc)
{
  grpread_info *info = (PTR) malloc (sizeof(grpread_info));
  if (info == NULL)
    return NULL;

  info->buf = NULL;
  info->buflen = 0;

  info->max_members = 5;
  info->members = (char **) malloc (5 * sizeof(char *));
  if (info->members == NULL)
    {
      free ((PTR) info);
      return NULL;
    }

  return info;
}

/* Read a group entry from STREAM, filling in G.  */
struct group *
DEFUN(__grpread, (stream, g), FILE *stream AND PTR CONST g)
{
  register grpread_info *CONST info = (grpread_info *) g;
  char *start, *end;
  register size_t i;

  /* Idiocy checks.  */
  if (stream == NULL)
    {
      errno = EINVAL;
      return NULL;
    }

  do
  {
    if (__getline (&info->buf, &info->buflen, stream) == -1)
      return NULL;
  } while (info->buf[0] == '#');

  start = info->buf;
  end = strchr (start, ':');
  if (end == NULL)
    return NULL;
  *end = '\0';
  info->g.gr_name = start;

  start = end + 1;
  end = strchr (start, ':');
  if (end == NULL)
    return NULL;
  *end = '\0';
  info->g.gr_passwd = start;

  info->g.gr_gid = (gid_t) strtol (end + 1, &end, 10);
  if (*end != ':')
    return NULL;

  i = 0;
  do
    {
      start = end + 1;
      end = strchr (start, ',');
      if (end == NULL)
	{
	  end = strchr (start, '\n');
	  if (end == start)
	    break;
	  if (end == NULL)
	    return NULL;
	  *end = '\0';
	  end = NULL;
	}
      else
	*end = '\0';

      if (i == info->max_members - 2)
	{
	  info->max_members += 5;
	  info->members = (char **)
	    realloc ((PTR) info->members, info->max_members * sizeof (char *));
	  if (info->members == NULL)
	    return NULL;
	}

      info->members[i++] = start;
    } while (end != NULL);
  info->members[i] = NULL;
  info->g.gr_mem = info->members;

  return &info->g;
}


/* Initialize the group set for the current user
   by reading the group database and using all groups
   of which USER is a member.  Also include GROUP.  */
int
DEFUN(initgroups, (user, group),
      CONST char *user AND gid_t group)
{
#ifdef NGROUPS_MAX
#if NGROUPS_MAX == 0
  return 0;
#else
  static PTR info = NULL;
  register FILE *stream;
  register struct group *g;
  gid_t groups[NGROUPS_MAX];
  register size_t n;

  if (info == NULL)
    {
      info = __grpalloc();
      if (info == NULL)
	return -1;
    }

  stream = __grpopen();
  if (stream == NULL)
    return -1;

  n = 0;
  groups[n++] = group;

  while (n < NGROUPS_MAX && (g = __grpread(stream, info)) != NULL)
    if (g->gr_gid != group)
      {
	register char **m;

	for (m = g->gr_mem; *m != NULL; ++m)
	  if (!strcmp(*m, user))
	    groups[n++] = g->gr_gid;
      }

  return setgroups(n, groups);
#endif
#else
  return 0;
#endif
}


/* Return a new stream open on the group file.  */
FILE *
DEFUN_VOID(__grpopen)
{
  return fopen("/etc/group", "r");
}

/* Read a group entry from STREAM.  */
struct group *
DEFUN(fgetgrent, (stream), FILE *stream)
{
  static PTR info = NULL;
  if (info == NULL)
    {
      info = __grpalloc();
      if (info == NULL)
	return NULL;
    }

  return __grpread(stream, info);
}

/* Rewind the stream.  */
void
DEFUN_VOID(setgrent)
{
  if (stream != NULL)
    rewind(stream);
}


/* Close the stream.  */
void
DEFUN_VOID(endgrent)
{
  if (stream != NULL)
    {
      (void) fclose(stream);
      stream = NULL;
    }
}


/* Read an entry from the stream.  */
struct group *
DEFUN_VOID(getgrent)
{
  static PTR info = NULL;
  if (info == NULL)
    {
      info = __grpalloc();
      if (info == NULL)
	return(NULL);
    }

  if (stream == NULL)
    {
      stream = __grpopen();
      if (stream == NULL)
	return(NULL);
    }

  return(__grpread(stream, info));
}

/* Search for an entry with a matching group ID.  */
struct group *
DEFUN(getgrgid, (gid), register gid_t gid)
{
  static PTR info = NULL;
  register FILE *stream;
  register struct group *g;

  if (info == NULL)
    {
      info = __grpalloc();
      if (info == NULL)
	return NULL;
    }

  stream = __grpopen();
  if (stream == NULL)
    return NULL;

  while ((g = __grpread(stream, info)) != NULL)
    if (g->gr_gid == (gid_t) gid)
      break;

  (void) fclose(stream);
  return g;
}

/* Search for an entry with a matching name.  */
struct group *
DEFUN(getgrnam, (name), register CONST char *name)
{
  static PTR info = NULL;
  register FILE *stream;
  register struct group *g;

  if (info == NULL)
    {
      info = __grpalloc();
      if (info == NULL)
	return NULL;
    }

  stream = __grpopen();
  if (stream == NULL)
    return NULL;

  while ((g = __grpread(stream, info)) != NULL)
    if (!strcmp(g->gr_name, name))
      break;

  (void) fclose(stream);
  return g;
}

